/**
 * 线程池管理类
 * 基于CPU核心数创建和管理Worker实例
 * 提供任务提交、队列管理、错误处理和资源释放等功能
 * 可用于并行处理各种类型的任务
 * @class ThreadPool
 * @extends EventEmitter
 */

import { EventEmitter } from '../common/event-emitter';
import { getOptimalThreadCount, OptimalThreadCountOptions } from '../common/helpers';

/**
 * 线程池事件枚举
 * 定义线程池可能触发的各种事件类型
 */
export enum ThreadPoolEvent {
  /** 
   * 任务开始事件
   * 当任务开始执行时触发
   * @event ThreadPoolEvent.TaskStart
   * @param {Object} data - 事件数据
   * @param {number} data.taskId - 任务ID
   * @param {any} data.data - 任务数据
   */
  TaskStart = 't1h0.common.threadPool.event.taskStart',
  /** 
   * 单个任务完成事件
   * 当一个任务成功完成时触发
   * @event ThreadPoolEvent.TaskComplete
   * @param {Object} data - 事件数据
   * @param {number} data.taskId - 任务ID
   * @param {any} data.data - 任务结果数据
   */
  TaskComplete = 't1h0.common.threadPool.event.taskComplete',
  /** 
   * 所有任务完成事件
   * 当所有任务都完成时触发
   * @event ThreadPoolEvent.AllTasksComplete
   */
  AllTasksComplete = 't1h0.common.threadPool.event.allTasksComplete',
  /** 
   * 任务错误事件
   * 当任务执行出错时触发
   * @event ThreadPoolEvent.TaskError
   * @param {Object} data - 事件数据
   * @param {number} data.taskId - 任务ID
   * @param {Error} data.error - 错误对象
   */
  TaskError = 't1h0.common.threadPool.event.taskError',
  /** 
   * 任务暂停事件
   * 当任务被暂停时触发
   * @event ThreadPoolEvent.TaskPause
   */
  TaskPause = 't1h0.common.threadPool.event.taskPause',
  /** 
   * 任务恢复事件
   * 当任务被恢复时触发
   * @event ThreadPoolEvent.TaskResume
   */
  TaskResume = 't1h0.common.threadPool.event.taskResume',
  /** 
   * 任务取消事件
   * 当任务被取消时触发
   * @event ThreadPoolEvent.TaskCancel
   * @param {Object} data - 事件数据
   * @param {number} data.taskId - 任务ID
   */
  TaskCancel = 't1h0.common.threadPool.event.taskCancel',
  /** 
   * 任务重试事件
   * 当任务开始重试时触发
   * @event ThreadPoolEvent.TaskRetry
   * @param {Object} data - 事件数据
   * @param {number} data.taskId - 任务ID
   * @param {number} data.retryCount - 当前重试次数
   */
  TaskRetry = 't1h0.common.threadPool.event.taskRetry',
  /** 
   * Worker错误事件
   * 当Worker发生错误时触发
   * @event ThreadPoolEvent.WorkerError
   * @param {Object} data - 事件数据
   * @param {number} data.workerIndex - Worker索引
   * @param {Error} data.error - 错误对象
   */
  WorkerError = 't1h0.common.threadPool.event.workerError',
  /** 
   * 线程池暂停事件
   * 当线程池被暂停时触发
   * @event ThreadPoolEvent.PoolPaused
   */
  PoolPaused = 't1h0.common.threadPool.event.poolPaused',
  /** 
   * 线程池恢复事件
   * 当线程池被恢复时触发
   * @event ThreadPoolEvent.PoolResumed
   */
  PoolResumed = 't1h0.common.threadPool.event.poolResumed',
  /**
   * 当批量任务大小变更时触发
   * @event ThreadPoolEvent.BatchSizeChanged
   * @param {Object} data - 事件数据
   * @param {number} data.oldSize - 变更前的批量大小
   * @param {number} data.newSize - 变更后的批量大小
   */
  BatchSizeChanged = 't1h0.common.threadPool.event.batchSizeChanged',
  /**
   * 当任务进度更新时触发
   * @event ThreadPoolEvent.TaskProgress
   */
  TaskProgress = 't1h0.common.threadPool.event.taskProgress',
  /**
   * 当线程池被销毁时触发
   * @event ThreadPoolEvent.PoolDestroyed
   */
  PoolDestroyed = 't1h0.common.threadPool.event.poolDestroyed'
}

/**
 * 任务类型枚举
 * 定义主线程与Worker之间通信的消息类型
 */
export enum CommandResponse {
  // 主线程发送的命令
  /** 主线程向Worker发送的任务命令 */
  Command_Task = 't1h0.common.threadPool.commandTask',
  /** 主线程向Worker发送的批量任务命令 */
  Command_BatchTask = 't1h0.common.threadPool.commandBatchTask',
  /** 主线程向Worker发送的暂停命令 */
  Command_Pause = 't1h0.common.threadPool.commandPause',
  /** 主线程向Worker发送的恢复命令 */
  Command_Resume = 't1h0.common.threadPool.commandResume',
  /** 主线程向Worker发送的取消命令 */
  Command_Cancel = 't1h0.common.threadPool.commandCancel',
  // Worker返回的响应
  /** Worker向主线程返回的任务完成响应 */
  Response_TaskComplete = 't1h0.common.threadPool.responseTaskComplete',
  /** Worker向主线程返回的任务暂停响应 */
  Response_TaskPaused = 't1h0.common.threadPool.responseTaskPaused',
  /** Worker向主线程返回的任务错误响应 */
  Response_TaskError = 't1h0.common.threadPool.responseTaskError',
  /** Worker向主线程返回的任务取消响应 */
  Response_TaskCanceled = 't1h0.common.threadPool.responseTaskCanceled',
  /** Worker向主线程返回的任务重试响应 */
  Response_TaskRetry = 't1h0.common.threadPool.responseTaskRetry',
  /** Worker向主线程返回的批量任务完成响应 */
  Response_BatchTaskComplete = 't1h0.common.threadPool.responseBatchTaskComplete',
  /** Worker向主线程返回的错误响应 */
  Response_Error = 't1h0.common.threadPool.responseError',
  /** Worker向主线程返回的进度响应 */
  Response_Progress = 't1h0.common.threadPool.responseProgress'

}

/**
 * 任务选项接口
 * 描述提交给线程池的任务参数
 * @template D - 任务数据类型
 * @template R - 任务结果类型
 */
interface ThreadPoolTaskOptions<D = any, R = any> {
  /** 任务数据 - 传递给Worker的具体数据 */
  data: D;
  /** 成功回调函数 - 任务成功完成时调用 */
  resolve: (result: R) => void;
  /** 失败回调函数 - 任务失败时调用 */
  reject: (error: Error) => void;
  /** 已尝试次数 - 当前任务已重试的次数，默认为0 */
  retries: number;
  /** 最大重试次数 - 任务最多可重试的次数，默认为3 */
  maxRetries: number;
  /** 任务类型 - 'single'表示单任务，'batch'表示批量任务 */
  type: 'single' | 'batch';
}

/**
 * 批量任务接口
 * 描述发送给Worker的批量任务数据
 * @property {number} batchId 批量任务ID
 * @property {Array<{ id: number; data: D }>} tasks 任务列表
 * @template D 任务数据类型
 */
export interface BatchTask<D = any> {
  /** 批量任务ID */
  batchId: number;
  /** 任务列表 */
  tasks: Array<{ id: number; data: D }>;
}

/**
 * 批量任务结果接口
 * 描述Worker返回的批量任务结果
 * @template R 任务结果数据类型
 */
export interface BatchTaskResult<R = any> {
  /** 批量任务ID */
  batchId: number;
  /** 任务结果列表 */
  results: Array<{ taskId: number; success: boolean; data?: R; error?: string }>;
}

/**
 * 线程池管理类
 * 基于CPU核心数创建和管理Worker实例
 * 提供任务提交、队列管理、错误处理和资源释放等功能
 * 可用于并行处理各种类型的任务
 * @template D - 任务数据类型
 * @template R - 任务结果类型
 */
export class ThreadPool<D = any, R = any> extends EventEmitter {
  /** 
   * Worker实例数组
   * 存储所有创建的Worker实例
   * @private
   */
  private __workers: Worker[] = [];
  /** 
   * 任务队列
   * 存储待处理的任务
   * @private
   */
  private __taskQueue: Array<{ id: number } & ThreadPoolTaskOptions<D, R>> = [];
  /** 
   * 活跃任务映射
   * 存储当前正在执行的任务及其对应的Worker
   * @private
   */
  private __activeTasks: Map<number, { worker: Worker; task: { id: number } & ThreadPoolTaskOptions<D, R> }> = new Map();
  /** 
   * 下一个任务ID
   * 用于生成唯一的任务标识符
   * @private
   */
  private __nextTaskId = 0;

  /** 
   * 下一个批量任务ID
   * 用于生成唯一的批量任务标识符
   * @private
   */
  private __nextBatchId = 0;

  /** 
   * 批量任务大小
   * 每个Worker一次处理的任务数
   * @private
   */
  private __batchSize = 5;

  /**
   * 批量任务映射
   * 存储批量任务ID与任务ID列表的映射关系
   * @private
   */
  private __batchTasks: Map<number, number[]> = new Map();

  /** 
   * 是否暂停
   * 标识线程池是否处于暂停状态
   * @private
   */
  private __isPaused = false;

  /** 
   * 暂停解析函数
   * 用于在恢复时解决暂停状态的Promise
   * @private
   */
  private __pauseResolve: (() => void) | null = null;

  /**
   * 最大工作线程数
   * 线程池可同时运行的最大Worker数量
   * @private
   */
  private __maxWorkers: number;

  /**
   * 创建线程池实例
   * @param {string} __workerPath - Worker脚本路径
   * @param {number|OptimalThreadCountOptions} __maxWorkers - 最大工作线程数，如果是数字，取该值和系统CPU核心数的较小值，否则需要根据系统CPU核心数和任务类型动态调整
   */
  constructor(
    private __workerPath: string,
    __maxWorkers: number | OptimalThreadCountOptions = navigator.hardwareConcurrency || 4
  ) {
    super();
    if (typeof __maxWorkers !== 'number') {
      __maxWorkers = getOptimalThreadCount(__maxWorkers as OptimalThreadCountOptions);
    }
    this.__maxWorkers = Math.min(__maxWorkers, navigator.hardwareConcurrency || 4);
    this.__initWorkers();
  }

  /**
   * 初始化Worker实例
   * 创建指定数量的Worker，并设置消息和错误处理回调
   */
  private __initWorkers(): void {
    for (let i = 0; i < this.__maxWorkers; i++) {
      const worker = new Worker(this.__workerPath, { type: 'module' });
      this.__workers.push(worker);

      /**
       * Worker消息处理回调
       * 处理来自Worker的错误
       */
      worker.onerror = (error) => {
        console.error(`Worker ${i} error:`, error);
        // 触发Worker错误事件
        this.emit(ThreadPoolEvent.WorkerError, { workerIndex: i, error });
        // 重启出错的Worker
        this.__workers.splice(i, 1);
        const newWorker = new Worker(this.__workerPath, { type: 'module' });
        this.__workers.push(newWorker);
      };
      /**
       * 处理来自Worker的各种消息响应
       */
      worker.onmessage = (e) => {
        const { type } = e.data;

        if (CommandResponse.Response_TaskComplete === type) {
          const { taskId, data } = e.data;
          return this.__handleTaskComplete(taskId, data);
        }
        if (CommandResponse.Response_BatchTaskComplete === type) {
          const { batchId, results } = e.data;
          return this.__handleBatchTaskComplete(batchId, results);
        }
        if (CommandResponse.Response_TaskError === type) {
          const { taskId, error } = e.data;
          return this.__handleTaskError(taskId, error);
        }
        if (CommandResponse.Response_TaskCanceled === type) {
          const { taskId } = e.data;
          return this.__handleTaskCanceled(taskId);
        }
        if (CommandResponse.Response_TaskRetry === type) {
          const { taskId, retryCount } = e.data;
          return this.__handleTaskRetry(taskId, retryCount);
        }
        if (CommandResponse.Response_TaskPaused === type) {
          const { taskId } = e.data;
          return this.__handleTaskPaused(taskId);
        }
        if (CommandResponse.Response_Error === type) {
          const { error } = e.data;
          return this.__handleError(error);
        }
        if (CommandResponse.Response_Progress === type) {
          const { taskType, data } = e.data;
          return this.__handleProgress(taskType, data);
        }
        throw new Error(`未知的任务类型: ${type}`);
      };
    }
  }

  /**
   * 处理任务完成响应
   * 当Worker返回任务完成消息时调用
   * @private
   * @param {number} taskId - 任务ID
   * @param {R} data - 任务执行结果数据
   * @returns {void}
   * @fires ThreadPoolEvent.TaskComplete - 当任务成功完成时触发
   * @fires ThreadPoolEvent.AllTasksComplete - 当所有任务都完成时触发
   */
  private __handleTaskComplete(taskId: number, data: R): void {
    const activeTask = this.__activeTasks.get(taskId);
    if (activeTask) {
      this.__activeTasks.delete(taskId);
      activeTask.task.resolve(data);
      // 触发任务完成事件，通知外部任务已完成
      this.emit(ThreadPoolEvent.TaskComplete, { taskId, data });
      // 检查是否所有任务都已完成
      if (this.__taskQueue.length === 0 && this.__activeTasks.size === 0) {
        this.emit(ThreadPoolEvent.AllTasksComplete); // 无参数事件
      }
      // 处理队列中的所有任务，为所有空闲Worker分配任务
      this.__processQueue();
    }
  }

  /**
   * 处理任务错误响应
   * 当Worker返回任务错误消息时调用
   * @private
   * @param {number} taskId - 任务ID
   * @param {Error} error - 任务执行错误对象
   * @returns {void}
   * @fires ThreadPoolEvent.TaskError - 当任务失败且超过最大重试次数时触发
   */
  private __handleTaskError(taskId: number, error: Error): void {
    const errorTask = this.__activeTasks.get(taskId);
    if (errorTask) {
      this.__activeTasks.delete(taskId);
      // 处理失败重试逻辑
      if (errorTask.task.retries < errorTask.task.maxRetries) {
        errorTask.task.retries++;
        // 直接将任务添加回队列末尾，保持原始类型和FIFO顺序
        this.__taskQueue.push(errorTask.task);
      } else {
        const errorMsg = `任务${taskId}失败，已重试${errorTask.task.retries}次，错误信息：${error.message}`;
        const taskError = new Error(errorMsg);
        errorTask.task.reject(taskError);
        // 触发任务错误事件，通知外部任务失败
        this.emit(ThreadPoolEvent.TaskError, { taskId, error: taskError });
      }
      // 处理队列中的所有任务，为所有空闲Worker分配任务
      this.__processQueue();
    }
  }

  /**
   * 处理任务取消响应
   * 当Worker返回任务取消消息时调用
   * @private
   * @param {number} taskId - 任务ID
   * @returns {void}
   */
  private __handleTaskCanceled(taskId: number): void {
    const canceledTask = this.__activeTasks.get(taskId);
    if (canceledTask) {
      this.__activeTasks.delete(taskId);
      canceledTask.task.reject(new Error(`任务${taskId}已取消`));
      // 处理队列中的所有任务，为所有空闲Worker分配任务
      this.__processQueue();
    }
  }

  /**
   * 处理任务重试响应
   * 当Worker返回任务重试消息时调用
   * @private
   * @param {number} taskId - 任务ID
   * @param {number} retryCount - 当前重试次数
   * @returns {void}
   * @fires ThreadPoolEvent.TaskRetry - 当任务开始重试时触发
   */
  private __handleTaskRetry(taskId: number, retryCount: number): void {
    const retryTask = this.__activeTasks.get(taskId);
    if (retryTask) {
      // console.log(`任务${taskId}重试中（${retryCount}/${retryTask.task.maxRetries}）`);
      // 触发任务重试事件，通知外部任务正在重试
      this.emit(ThreadPoolEvent.TaskRetry, { taskId, retryCount });
    }
  }

  /**
   * 处理批量任务完成响应
   * 当Worker返回批量任务完成消息时调用
   * @private
   * @param {number} batchId - 批量任务ID
   * @param {Array<{ taskId: number; success: boolean; data?: R; error?: string }> | undefined} results - 批量任务结果数组
   * @returns {void}
   * @fires ThreadPoolEvent.AllTasksComplete - 当所有任务都完成时触发
   */
  private __handleBatchTaskComplete(batchId: number, results: Array<{ taskId: number; success: boolean; data?: R; error?: string }> | undefined): void {
    // console.log(`批量任务${batchId}完成，处理结果数量: ${results?.length || 0}`);
    // 处理完成后删除映射
    this.__batchTasks.delete(batchId);

    // 使用BatchTaskResult接口类型处理结果
    const batchResult: BatchTaskResult<R> = {
      batchId: batchId,
      results: results || []
    };
    if (batchResult.results && Array.isArray(batchResult.results)) {
      batchResult.results.forEach(result => {
        const { taskId, success, data, error } = result;
        if (success && data) {
          // 调用已有的__handleTaskComplete方法处理成功任务
          this.__handleTaskComplete(taskId, data);
        } else if (!success && error) {
          // 调用已有的__handleTaskError方法处理失败任务
          this.__handleTaskError(taskId, new Error(error));
        }
      });
    }
    // 检查是否所有任务都已完成
    if (this.__taskQueue.length === 0 && this.__activeTasks.size === 0) {
      this.emit(ThreadPoolEvent.AllTasksComplete);
    }
  }

  /**
   * 处理任务进度响应
   * 当Worker返回任务进度消息时调用
   * @private
   * @param {number} taskId - 任务ID
   * @param {number} progress - 任务进度百分比
   * @param {string} taskType - 任务类型 (total 或 subtask)
   * @param {any} data - 额外的进度数据
   * @returns {void}
   * @fires ThreadPoolEvent.TaskProgress - 当任务进度更新时触发
   */
  private __handleProgress(taskType: string = 'subtask', data: any = {}): void {
    // 触发任务进度事件，通知外部任务进度更新
    this.emit(ThreadPoolEvent.TaskProgress, { taskType, data });
  }

  /**
   * 处理Worker错误响应
   * 当Worker返回错误消息时调用
   * @private
   * @param {Error} error - 错误对象
   * @returns {void}
   * @fires ThreadPoolEvent.WorkerError - 当Worker发生错误时触发
   */
  private __handleError(error: Error): void {
    // 触发Worker错误事件，通知外部Worker发生错误
    this.emit(ThreadPoolEvent.WorkerError, { error });
  }

  private __handleTaskPaused(taskId: number): void {
    // 单个任务暂停，将任务重新加入队列
    const pausedTask = this.__activeTasks.get(taskId);
    if (pausedTask) {
      this.__activeTasks.delete(taskId);
      // 将暂停的任务重新加入队列
      this.__taskQueue.push({
        ...pausedTask.task,
        type: 'single'
      });
    }
    // 处理队列中的所有任务，为所有空闲Worker分配任务
    this.__processQueue();
  }

  /**
   * 提交单个任务到队列
   * @param {Partial<ThreadPoolTaskOptions<D, R>> & Pick<ThreadPoolTaskOptions<D, R>, 'data' | 'resolve' | 'reject'>} options - 任务选项
   * @returns void
   */
  addTask(options: Partial<ThreadPoolTaskOptions<D, R>> & Pick<ThreadPoolTaskOptions<D, R>, 'data' | 'resolve' | 'reject'>): void {
    const { data, resolve, reject, retries = 0, maxRetries = 3 } = options;
    const taskId = this.__nextTaskId++;
    this.__taskQueue.push({
      id: taskId,
      type: 'single',
      data,
      resolve,
      reject,
      retries,
      maxRetries
    });
    // console.log('添加任务ID:', taskId, ',当前队列:', this.__taskQueue.length)

    this.__processQueue();
  }

  /**
   * 批量提交任务到队列
   * @param {Array<Partial<ThreadPoolTaskOptions<D, R>> & Pick<ThreadPoolTaskOptions<D, R>, 'data' | 'resolve' | 'reject'>>} tasks - 任务选项对象数组
   * @returns void
   */
  addBatchTasks(tasks: Array<Partial<ThreadPoolTaskOptions<D, R>> & Pick<ThreadPoolTaskOptions<D, R>, 'data' | 'resolve' | 'reject'>>): void {
    tasks.forEach(options => {
      const { data, resolve, reject, retries = 0, maxRetries = 3 } = options;
      const taskId = this.__nextTaskId++;
      this.__taskQueue.push({
        id: taskId,
        type: 'batch',
        data,
        resolve,
        reject,
        retries,
        maxRetries
      });
    });

    // 所有任务添加完成后，手动处理队列
    this.__processQueue();
  }

  /**
   * 处理队列中的任务
   * 遍历所有Worker，为空闲的Worker分配任务
   * @private
   */
  private __processQueue(): void {
    if (this.__isPaused) {
      return;
    }

    // 找出空闲的Worker并分配任务
    for (const worker of this.__workers) {
      if (this.__taskQueue.length === 0) break;

      // 检查Worker是否空闲
      const isWorkerBusy = Array.from(this.__activeTasks.values()).some(
        (task) => task.worker === worker
      );

      if (!isWorkerBusy) {
        this.__processNextTask(worker);
      }
    }
  }

  /**
   * 为指定Worker处理下一个任务或批量任务
   * @private
   * @param {Worker} worker - 要分配任务的Worker实例
   */
  private __processNextTask(worker: Worker): void {
    if (this.__isPaused || this.__taskQueue.length === 0) {
      return;
    }

    // 获取队列中的第一个任务
    const nextTask = this.__taskQueue[0];

    if (nextTask.type === 'single') {
      // 处理单个任务
      const singleTask = this.__taskQueue.shift()!;

      // 添加到activeTasks
      this.__activeTasks.set(singleTask.id, { worker, task: singleTask });
      // 触发任务开始事件
      this.emit(ThreadPoolEvent.TaskStart, { taskId: singleTask.id, data: singleTask.data });

      // 发送单任务
      worker.postMessage({
        type: CommandResponse.Command_Task,
        taskId: singleTask.id,
        data: singleTask.data
      });
    } else if (nextTask.type === 'batch') {
        // 处理批量任务
        // 收集所有批量任务，最多取__batchSize个
        let batchSize = 0;
        const batchTasks = [];
        const nonBatchTasks = [];

        // 遍历队列，分离批量任务和非批量任务
        while (this.__taskQueue.length > 0 && batchSize < this.__batchSize) {
          const task = this.__taskQueue.shift()!;

          if (task.type === 'batch') {
            batchTasks.push(task);
            batchSize++;
          } else {
            nonBatchTasks.push(task);
          }
        }

        // 将非批量任务放回队列前端，保持FIFO顺序
        this.__taskQueue.unshift(...nonBatchTasks);

      if (batchTasks.length === 0) {
        // 如果没有批量任务，尝试处理一个单任务
        return this.__processNextTask(worker);
      }

      // 创建新的批量ID
      const batchId = this.__nextBatchId++;
      // 存储批量任务ID与任务ID列表的映射
      this.__batchTasks.set(batchId, batchTasks.map(task => task.id));

      const tasksData = batchTasks.map(task => ({
        id: task.id,
        data: task.data
      }));

      // 将批量任务中的每个任务添加到activeTasks
      batchTasks.forEach(task => {
        this.__activeTasks.set(task.id, { worker, task });
        // 触发任务开始事件
        this.emit(ThreadPoolEvent.TaskStart, { taskId: task.id, data: task.data });
      });

      // 使用BatchTask接口类型发送批量任务
      const batchTask: BatchTask = {
        batchId: batchId,
        tasks: tasksData
      };
      worker.postMessage({
        type: CommandResponse.Command_BatchTask,
        ...batchTask
      });
    }else{
      throw new Error('未知任务类型');
    }
  }

  /**
   * 暂停所有任务
   * 停止处理新任务，并通知所有Worker暂停当前任务
   */
  pause(): void {
    this.__isPaused = true;
    // 触发线程池暂停事件
    this.emit(ThreadPoolEvent.PoolPaused);

    // 通知所有Worker暂停
    for (const worker of this.__workers) {
      worker.postMessage({ type: CommandResponse.Command_Pause });
      // 触发任务暂停事件
      this.emit(ThreadPoolEvent.TaskPause);
    }
  }

  /**
   * 恢复所有任务
   * 恢复处理队列中的任务，并通知所有Worker继续执行
   */
  resume(): void {
    this.__isPaused = false;
    // 触发线程池恢复事件
    this.emit(ThreadPoolEvent.PoolResumed);

    // 通知所有Worker恢复
    for (const worker of this.__workers) {
      worker.postMessage({ type: CommandResponse.Command_Resume });
      // 触发任务恢复事件
      this.emit(ThreadPoolEvent.TaskResume);
    }

    // 处理队列中的任务
    this.__processQueue();

    // 解决暂停状态的Promise
    if (this.__pauseResolve) {
      this.__pauseResolve();
      this.__pauseResolve = null;
    }
  }

  /**
   * 取消所有任务
   * 清空任务队列，取消所有正在执行的任务
   */
  cancel(): void {
    this.__taskQueue = [];
    const canceledTaskIds = Array.from(this.__activeTasks.keys());
    this.__activeTasks.clear();

    // 通知所有Worker取消
    for (const worker of this.__workers) {
      worker.postMessage({ type: CommandResponse.Command_Cancel });
    }

    // 触发任务取消事件
    canceledTaskIds.forEach(taskId => {
      this.emit(ThreadPoolEvent.TaskCancel, { taskId });
    });
  }



  /**
   * 设置批量任务大小
   * @param {number} size - 新的批量任务大小
   * @returns {boolean} 是否设置成功
   */
  setBatchSize(size: number): boolean {
    if (typeof size !== 'number' || size < 1 || !Number.isInteger(size)) {
      return false;
    }
    const oldSize = this.__batchSize;
    this.__batchSize = size;
    this.emit(ThreadPoolEvent.BatchSizeChanged, { oldSize, newSize: size });
    return true;
  }

  /**
   * 销毁线程池
   * 取消所有任务并终止所有Worker实例，释放资源
   */
  destroy(): void {
    this.cancel();
    for (const worker of this.__workers) {
      worker.terminate();
    }
    this.__workers = [];
    // 触发线程池销毁事件
    this.emit(ThreadPoolEvent.PoolDestroyed);
  }

  /**
   * 等待所有任务完成
   * @returns {Promise<void>} - 当所有任务完成时解析的Promise
   * @example
   * ```typescript
   * // 等待所有任务完成
   * await threadPool.waitForCompletion();
   * console.log('所有任务已完成');
   * ```
   */
  waitForCompletion(): Promise<void> {
    // 如果当前没有任务和活跃任务，直接返回已解决的Promise
    if (this.__taskQueue.length === 0 && this.__activeTasks.size === 0) {
      return Promise.resolve();
    }

    // 创建并返回一个Promise，定期检查任务是否全部完成
    return new Promise((resolve) => {
      const checkComplete = () => {
        if (this.__taskQueue.length === 0 && this.__activeTasks.size === 0) {
          resolve();
        } else {
          // 每100毫秒检查一次
          setTimeout(checkComplete, 100);
        }
      };
      checkComplete();
    });
  }

  /**
   * 获取当前活跃任务数量
   * @returns {number} - 当前正在执行的任务数量
   */
  getActiveTaskCount(): number {
    return this.__activeTasks.size;
  }

  /**
   * 获取当前队列中任务数量
   * @returns {number} - 等待执行的任务数量
   */
  getQueuedTaskCount(): number {
    return this.__taskQueue.length;
  }

  /**
   * 获取当前批量任务大小
   * @returns {number} 当前批量任务大小
   */
  get batchSize(): number {
    return this.__batchSize;
  }
}